/*
 * File:          sidl_Loader_Module.c
 * Symbol:        sidl.Loader-v0.9.15
 * Symbol Type:   class
 * Babel Version: 1.0.4
 * Release:       $Name: V2-9-0b $
 * Revision:      @(#) $Id: sidl_Loader_Module.c,v 1.6 2007/09/27 19:35:27 painter Exp $
 * Description:   implement a C extension type for a sidl extendable
 * 
 * Copyright (c) 2000-2002, The Regents of the University of California.
 * Produced at the Lawrence Livermore National Laboratory.
 * Written by the Components Team <components@llnl.gov>
 * All rights reserved.
 * 
 * This file is part of Babel. For more information, see
 * http://www.llnl.gov/CASC/components/. Please read the COPYRIGHT file
 * for Our Notice and the LICENSE file for the GNU Lesser General Public
 * License.
 * 
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License (as published by
 * the Free Software Foundation) version 2.1 dated February 1999.
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
 * conditions of the GNU Lesser General Public License for more details.
 * 
 * You should have recieved a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 * 
 * WARNING: Automatically generated; changes will be lost
 * 
 */

/*
 * THIS CODE IS AUTOMATICALLY GENERATED BY THE BABEL
 * COMPILER. DO NOT EDIT THIS!
 * 
 * This file contains the implementation of a Python C
 * extension type (i.e. a Python type implemented in C).
 * This extension type provides Python interface to the
 * sidl type sidl.Loader.
 */


/**
 * Symbol "sidl.Loader" (version 0.9.15)
 * 
 * Class <code>Loader</code> manages dyanamic loading and symbol name
 * resolution for the sidl runtime system.  The <code>Loader</code> class
 * manages a library search path and keeps a record of all libraries
 * loaded through this interface, including the initial "global" symbols
 * in the main program.
 * 
 * Unless explicitly set, the <code>Loader</code> uses the default
 * <code>sidl.Finder</code> implemented in <code>sidl.DFinder</code>.
 * This class searches the filesystem for <code>.scl</code> files when
 * trying to find a class. The initial path is taken from the
 * environment variable SIDL_DLL_PATH, which is a semi-colon
 * separated sequence of URIs as described in class <code>DLL</code>.
 */
#include <Python.h>
#include <stdlib.h>
#include <string.h>
#ifndef included_sidl_BaseClass_h
#include "sidl_BaseClass.h"
#endif
#ifndef included_sidl_ClassInfo_h
#include "sidl_ClassInfo.h"
#endif
#ifndef included_sidl_rmi_ProtocolFactory_h
#include "sidl_rmi_ProtocolFactory.h"
#endif
#ifndef included_sidl_rmi_InstanceRegistry_h
#include "sidl_rmi_InstanceRegistry.h"
#endif
#ifndef included_sidl_rmi_InstanceHandle_h
#include "sidl_rmi_InstanceHandle.h"
#endif
#ifndef included_sidl_rmi_Invocation_h
#include "sidl_rmi_Invocation.h"
#endif
#ifndef included_sidl_rmi_Response_h
#include "sidl_rmi_Response.h"
#endif
#ifndef included_sidl_rmi_ServerRegistry_h
#include "sidl_rmi_ServerRegistry.h"
#endif
#ifndef included_sidl_rmi_ConnectRegistry_h
#include "sidl_rmi_ConnectRegistry.h"
#endif
#ifndef included_sidl_io_Serializable_h
#include "sidl_io_Serializable.h"
#endif
#include "sidl_Exception.h"

#ifndef NULL
#define NULL 0
#endif

#include "sidl_thread.h"
#ifdef HAVE_PTHREAD
static struct sidl_recursive_mutex_t sidl_Loader__mutex= SIDL_RECURSIVE_MUTEX_INITIALIZER;
#define LOCK_STATIC_GLOBALS sidl_recursive_mutex_lock( &sidl_Loader__mutex )
#define UNLOCK_STATIC_GLOBALS sidl_recursive_mutex_unlock( &sidl_Loader__mutex )
/* #define HAVE_LOCKED_STATIC_GLOBALS (sidl_recursive_mutex_trylock( &sidl_Loader__mutex )==EDEADLOCK) */
#else
#define LOCK_STATIC_GLOBALS
#define UNLOCK_STATIC_GLOBALS
/* #define HAVE_LOCKED_STATIC_GLOBALS (1) */
#endif

#define sidl_Loader_INTERNAL 1
#include "sidl_Loader_Module.h"
#ifndef included_sidl_Loader_IOR_h
#include "sidl_Loader_IOR.h"
#endif
#include "sidlObjA.h"
#include "sidlPyArrays.h"
#include "Numeric/arrayobject.h"
#ifndef included_sidl_Loader_h
#include "sidl_Loader.h"
#endif
#ifndef included_sidl_header_h
#include "sidl_header.h"
#endif
#ifndef included_sidl_interface_IOR_h
#include "sidl_interface_IOR.h"
#endif
#include "sidl_rmi_NetworkException_Module.h"
#include "sidl_BaseClass_Module.h"
#include "sidl_BaseInterface_Module.h"
#include "sidl_ClassInfo_Module.h"
#include "sidl_DLL_Module.h"
#include "sidl_Finder_Module.h"
#include "sidl_RuntimeException_Module.h"
#include "sidl_rmi_Call_Module.h"
#include "sidl_rmi_Return_Module.h"
#include "sidl_rmi_Ticket_Module.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

/*
 * connect_loaded is a boolean value showing if the IHConnect for this object has been loaded into the connectRegistry
 */

static int connect_loaded = 0;

/*
 * lang_inited is a boolean value showing if we have already imported all the nescessary modules
 */

static int lang_inited = 0;

#define LANG_SPECIFIC_INIT() if(!lang_inited) { \
  lang_inited = 1; \
  sidl_BaseClass__import(); \
  sidl_BaseInterface__import(); \
  sidl_ClassInfo__import(); \
  sidl_DLL__import(); \
  sidl_Finder__import(); \
  sidl_Loader__import(); \
  sidl_RuntimeException__import(); \
  sidl_rmi_Ticket__import(); \
}
/**
 * Cast method for interface and class type conversions.
 */
struct sidl_Loader__object*
sidl_Loader__rmicast(
  void* obj, struct sidl_BaseInterface__object **_ex);

/**
 * RMI connector function for the class. (no addref)
 */
struct sidl_Loader__object*
sidl_Loader__connectI(const char * url, sidl_bool ar, struct                  \
  sidl_BaseInterface__object **_ex);

/* Static variables to hold version of IOR */
static const int32_t s_IOR_MAJOR_VERSION = 1;
static const int32_t s_IOR_MINOR_VERSION = 0;

/* Static variables for managing EPV initialization. */
static int s_remote_initialized = 0;

static struct sidl_Loader__epv s_rem_epv__sidl_loader;

static struct sidl_BaseClass__epv  s_rem_epv__sidl_baseclass;

static struct sidl_BaseInterface__epv  s_rem_epv__sidl_baseinterface;


/* REMOTE CAST: dynamic type casting for remote objects. */
static void* remote_sidl_Loader__cast(
  struct sidl_Loader__object* self,
  const char* name, sidl_BaseInterface* _ex)
{
  int
    cmp0,
    cmp1;
  void* cast = NULL;
  *_ex = NULL; /* default to no exception */
  cmp0 = strcmp(name, "sidl.BaseInterface");
  if (!cmp0) {
    (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
    cast = &((*self).d_sidl_baseclass.d_sidl_baseinterface);
    return cast;
  }
  else if (cmp0 < 0) {
    cmp1 = strcmp(name, "sidl.BaseClass");
    if (!cmp1) {
      (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
      cast = ((struct sidl_BaseClass__object*)self);
      return cast;
    }
  }
  else if (cmp0 > 0) {
    cmp1 = strcmp(name, "sidl.Loader");
    if (!cmp1) {
      (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
      cast = ((struct sidl_Loader__object*)self);
      return cast;
    }
  }
  if ((*self->d_epv->f_isType)(self,name, _ex)) {
    void* (*func)(struct sidl_rmi_InstanceHandle__object*, struct             \
      sidl_BaseInterface__object**) = 
      (void* (*)(struct sidl_rmi_InstanceHandle__object*, struct              \
        sidl_BaseInterface__object**)) 
      sidl_rmi_ConnectRegistry_getConnect(name, _ex);SIDL_CHECK(*_ex);
    cast =  (*func)(((struct sidl_Loader__remote*)self->d_data)->d_ih, _ex);
  }

  return cast;
  EXIT:
  return NULL;
}

/* REMOTE DELETE: call the remote destructor for the object. */
static void remote_sidl_Loader__delete(
  struct sidl_Loader__object* self,
  sidl_BaseInterface* _ex)
{
  *_ex = NULL;
  free((void*) self);
}

/* REMOTE GETURL: call the getURL function for the object. */
static char* remote_sidl_Loader__getURL(
  struct sidl_Loader__object* self, sidl_BaseInterface* _ex)
{
  struct sidl_rmi_InstanceHandle__object *conn = ((struct                     \
    sidl_Loader__remote*)self->d_data)->d_ih;
  *_ex = NULL;
  if(conn != NULL) {
    return sidl_rmi_InstanceHandle_getObjectURL(conn, _ex);
  }
  return NULL;
}

/* REMOTE ADDREF: For internal babel use only! Remote addRef. */
static void remote_sidl_Loader__raddRef(
  struct sidl_Loader__object* self,sidl_BaseInterface* _ex)
{
  sidl_BaseException netex = NULL;
  /* initialize a new invocation */
  sidl_BaseInterface _throwaway = NULL;
  struct sidl_rmi_InstanceHandle__object *_conn = ((struct                    \
    sidl_Loader__remote*)self->d_data)->d_ih;
  sidl_rmi_Response _rsvp = NULL;
  sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, \
    "addRef", _ex ); SIDL_CHECK(*_ex);
  /* send actual RMI request */
  _rsvp = sidl_rmi_Invocation_invokeMethod(_inv,_ex);SIDL_CHECK(*_ex);
  /* Check for exceptions */
  netex = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);
  if(netex != NULL) {
    sidl_BaseInterface throwaway_exception = NULL;
    *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(netex,            \
      &throwaway_exception);
    return;
  }

  /* cleanup and return */
  EXIT:
  if(_inv) { sidl_rmi_Invocation_deleteRef(_inv,&_throwaway); }
  if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp,&_throwaway); }
  return;
}

/* REMOTE ISREMOTE: returns true if this object is Remote (it is). */
static sidl_bool
remote_sidl_Loader__isRemote(
    struct sidl_Loader__object* self, 
    sidl_BaseInterface *_ex) {
  *_ex = NULL;
  return TRUE;
}

/* REMOTE METHOD STUB:_set_hooks */
static void
remote_sidl_Loader__set_hooks(
  /* in */ struct sidl_Loader__object* self ,
  /* in */ sidl_bool on,
  /* out */ struct sidl_BaseInterface__object* *_ex)
{
  LANG_SPECIFIC_INIT();
  *_ex = NULL;
  {
    /* initialize a new invocation */
    sidl_BaseInterface _throwaway = NULL;
    sidl_BaseException _be = NULL;
    sidl_rmi_Response _rsvp = NULL;
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct                 \
      sidl_Loader__remote*)self->d_data)->d_ih;
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation(      \
      _conn, "_set_hooks", _ex ); SIDL_CHECK(*_ex);

    /* pack in and inout arguments */
    sidl_rmi_Invocation_packBool( _inv, "on", on, _ex);SIDL_CHECK(*_ex);

    /* send actual RMI request */
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);

    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
    if(_be != NULL) {
      sidl_BaseInterface throwaway_exception = NULL;
sidl_BaseException_addLine(_be, "Exception unserialized from sidl.Loader._set_hooks.", &throwaway_exception);
      *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(_be,            \
        &throwaway_exception);
      goto EXIT;
    }

    /* unpack out and inout arguments */

    /* cleanup and return */
    EXIT:
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
    return;
  }
}

/* REMOTE EXEC: call the exec function for the object. */
static void remote_sidl_Loader__exec(
  struct sidl_Loader__object* self,const char* methodName,
  sidl_rmi_Call inArgs,
  sidl_rmi_Return outArgs,
  sidl_BaseInterface* _ex)
{
  *_ex = NULL;
}

/* REMOTE METHOD STUB:addRef */
static void
remote_sidl_Loader_addRef(
  /* in */ struct sidl_Loader__object* self ,
  /* out */ struct sidl_BaseInterface__object* *_ex)
{
  LANG_SPECIFIC_INIT();
  *_ex = NULL;
  {
    struct sidl_Loader__remote* r_obj = (struct                               \
      sidl_Loader__remote*)self->d_data;
    LOCK_STATIC_GLOBALS;
    r_obj->d_refcount++;
    UNLOCK_STATIC_GLOBALS;
  }
}

/* REMOTE METHOD STUB:deleteRef */
static void
remote_sidl_Loader_deleteRef(
  /* in */ struct sidl_Loader__object* self ,
  /* out */ struct sidl_BaseInterface__object* *_ex)
{
  LANG_SPECIFIC_INIT();
  *_ex = NULL;
  {
    struct sidl_Loader__remote* r_obj = (struct                               \
      sidl_Loader__remote*)self->d_data;
    LOCK_STATIC_GLOBALS;
    r_obj->d_refcount--;
    if(r_obj->d_refcount == 0) {
      sidl_rmi_InstanceHandle_deleteRef(r_obj->d_ih, _ex);
      free(r_obj);
      free(self);
    }
    UNLOCK_STATIC_GLOBALS;
  }
}

/* REMOTE METHOD STUB:isSame */
static sidl_bool
remote_sidl_Loader_isSame(
  /* in */ struct sidl_Loader__object* self ,
  /* in */ struct sidl_BaseInterface__object* iobj,
  /* out */ struct sidl_BaseInterface__object* *_ex)
{
  LANG_SPECIFIC_INIT();
  *_ex = NULL;
  {
    /* initialize a new invocation */
    sidl_BaseInterface _throwaway = NULL;
    sidl_BaseException _be = NULL;
    sidl_rmi_Response _rsvp = NULL;
    sidl_bool _retval = FALSE;
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct                 \
      sidl_Loader__remote*)self->d_data)->d_ih;
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation(      \
      _conn, "isSame", _ex ); SIDL_CHECK(*_ex);

    /* pack in and inout arguments */
    if(iobj){
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj,       \
        _ex);SIDL_CHECK(*_ex);
      sidl_rmi_Invocation_packString( _inv, "iobj", _url, _ex);SIDL_CHECK(    \
        *_ex);
      free((void*)_url);
    } else {
      sidl_rmi_Invocation_packString( _inv, "iobj", NULL, _ex);SIDL_CHECK(    \
        *_ex);
    }

    /* send actual RMI request */
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);

    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
    if(_be != NULL) {
      sidl_BaseInterface throwaway_exception = NULL;
sidl_BaseException_addLine(_be, "Exception unserialized from sidl.Loader.isSame.", &throwaway_exception);
      *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(_be,            \
        &throwaway_exception);
      goto EXIT;
    }

    /* extract return value */
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(\
      *_ex);

    /* unpack out and inout arguments */

    /* cleanup and return */
    EXIT:
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
    return _retval;
  }
}

/* REMOTE METHOD STUB:isType */
static sidl_bool
remote_sidl_Loader_isType(
  /* in */ struct sidl_Loader__object* self ,
  /* in */ const char* name,
  /* out */ struct sidl_BaseInterface__object* *_ex)
{
  LANG_SPECIFIC_INIT();
  *_ex = NULL;
  {
    /* initialize a new invocation */
    sidl_BaseInterface _throwaway = NULL;
    sidl_BaseException _be = NULL;
    sidl_rmi_Response _rsvp = NULL;
    sidl_bool _retval = FALSE;
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct                 \
      sidl_Loader__remote*)self->d_data)->d_ih;
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation(      \
      _conn, "isType", _ex ); SIDL_CHECK(*_ex);

    /* pack in and inout arguments */
    sidl_rmi_Invocation_packString( _inv, "name", name, _ex);SIDL_CHECK(*_ex);

    /* send actual RMI request */
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);

    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
    if(_be != NULL) {
      sidl_BaseInterface throwaway_exception = NULL;
sidl_BaseException_addLine(_be, "Exception unserialized from sidl.Loader.isType.", &throwaway_exception);
      *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(_be,            \
        &throwaway_exception);
      goto EXIT;
    }

    /* extract return value */
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(\
      *_ex);

    /* unpack out and inout arguments */

    /* cleanup and return */
    EXIT:
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
    return _retval;
  }
}

/* REMOTE METHOD STUB:getClassInfo */
static struct sidl_ClassInfo__object*
remote_sidl_Loader_getClassInfo(
  /* in */ struct sidl_Loader__object* self ,
  /* out */ struct sidl_BaseInterface__object* *_ex)
{
  LANG_SPECIFIC_INIT();
  *_ex = NULL;
  {
    /* initialize a new invocation */
    sidl_BaseInterface _throwaway = NULL;
    sidl_BaseException _be = NULL;
    sidl_rmi_Response _rsvp = NULL;
    char*_retval_str = NULL;
    struct sidl_ClassInfo__object* _retval = 0;
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct                 \
      sidl_Loader__remote*)self->d_data)->d_ih;
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation(      \
      _conn, "getClassInfo", _ex ); SIDL_CHECK(*_ex);

    /* pack in and inout arguments */

    /* send actual RMI request */
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);

    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
    if(_be != NULL) {
      sidl_BaseInterface throwaway_exception = NULL;
sidl_BaseException_addLine(_be, "Exception unserialized from sidl.Loader.getClassInfo.", &throwaway_exception);
      *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(_be,            \
        &throwaway_exception);
      goto EXIT;
    }

    /* extract return value */
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str,           \
      _ex);SIDL_CHECK(*_ex);
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE, _ex);SIDL_CHECK(   \
      *_ex);

    /* unpack out and inout arguments */

    /* cleanup and return */
    EXIT:
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
    return _retval;
  }
}

/* REMOTE EPV: create remote entry point vectors (EPVs). */
static void sidl_Loader__init_remote_epv(void)
{
  /* assert( HAVE_LOCKED_STATIC_GLOBALS ); */
  struct sidl_Loader__epv*        epv = &s_rem_epv__sidl_loader;
  struct sidl_BaseClass__epv*     e0  = &s_rem_epv__sidl_baseclass;
  struct sidl_BaseInterface__epv* e1  = &s_rem_epv__sidl_baseinterface;

  epv->f__cast             = remote_sidl_Loader__cast;
  epv->f__delete           = remote_sidl_Loader__delete;
  epv->f__exec             = remote_sidl_Loader__exec;
  epv->f__getURL           = remote_sidl_Loader__getURL;
  epv->f__raddRef          = remote_sidl_Loader__raddRef;
  epv->f__isRemote         = remote_sidl_Loader__isRemote;
  epv->f__set_hooks        = remote_sidl_Loader__set_hooks;
  epv->f__ctor             = NULL;
  epv->f__ctor2            = NULL;
  epv->f__dtor             = NULL;
  epv->f_addRef            = remote_sidl_Loader_addRef;
  epv->f_deleteRef         = remote_sidl_Loader_deleteRef;
  epv->f_isSame            = remote_sidl_Loader_isSame;
  epv->f_isType            = remote_sidl_Loader_isType;
  epv->f_getClassInfo      = remote_sidl_Loader_getClassInfo;

  e0->f__cast        = (void* (*)(struct sidl_BaseClass__object*,const char*, \
    sidl_BaseInterface*)) epv->f__cast;
  e0->f__delete      = (void (*)(struct sidl_BaseClass__object*,              \
    sidl_BaseInterface*)) epv->f__delete;
  e0->f__getURL      = (char* (*)(struct sidl_BaseClass__object*,             \
    sidl_BaseInterface*)) epv->f__getURL;
  e0->f__raddRef     = (void (*)(struct sidl_BaseClass__object*,              \
    sidl_BaseInterface*)) epv->f__raddRef;
  e0->f__isRemote    = (sidl_bool (*)(struct sidl_BaseClass__object*,         \
    sidl_BaseInterface*)) epv->f__isRemote;
  e0->f__set_hooks   = (void (*)(struct sidl_BaseClass__object*,int32_t,      \
    sidl_BaseInterface*)) epv->f__set_hooks;
  e0->f__exec        = (void (*)(struct sidl_BaseClass__object*,const char*,  \
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct      \
    sidl_BaseInterface__object **)) epv->f__exec;
  e0->f_addRef       = (void (*)(struct sidl_BaseClass__object*,struct        \
    sidl_BaseInterface__object **)) epv->f_addRef;
  e0->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,struct        \
    sidl_BaseInterface__object **)) epv->f_deleteRef;
  e0->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,struct   \
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **))        \
    epv->f_isSame;
  e0->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,const    \
    char*,struct sidl_BaseInterface__object **)) epv->f_isType;
  e0->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(struct             \
    sidl_BaseClass__object*,struct sidl_BaseInterface__object **))            \
    epv->f_getClassInfo;

  e1->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*))     \
    epv->f__cast;
  e1->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
  e1->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
  e1->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
  e1->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*))             \
    epv->f__isRemote;
  e1->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*))         \
    epv->f__set_hooks;
  e1->f__exec        = (void (*)(void*,const char*,struct                     \
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct             \
    sidl_BaseInterface__object **)) epv->f__exec;
  e1->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) \
    epv->f_addRef;
  e1->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) \
    epv->f_deleteRef;
  e1->f_isSame       = (sidl_bool (*)(void*,struct                            \
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **))        \
    epv->f_isSame;
  e1->f_isType       = (sidl_bool (*)(void*,const char*,struct                \
    sidl_BaseInterface__object **)) epv->f_isType;
  e1->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct       \
    sidl_BaseInterface__object **)) epv->f_getClassInfo;

  s_remote_initialized = 1;
}

/* Create an instance that connects to an existing remote object. */
static struct sidl_Loader__object*
sidl_Loader__remoteConnect(const char *url, sidl_bool ar, sidl_BaseInterface  \
  *_ex)
{
  struct sidl_Loader__object* self;

  struct sidl_Loader__object* s0;
  struct sidl_BaseClass__object* s1;

  struct sidl_Loader__remote* r_obj;
  sidl_rmi_InstanceHandle instance = NULL;
  char* objectID = NULL;
  objectID = NULL;
  *_ex = NULL;
  if(url == NULL) {return NULL;}
  objectID = sidl_rmi_ServerRegistry_isLocalObject(url, _ex);
  if(objectID) {
    sidl_BaseInterface bi = (                                                 \
      sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(       \
      objectID, _ex); SIDL_CHECK(*_ex);
    return sidl_Loader__rmicast(bi,_ex);SIDL_CHECK(*_ex);
  }
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar, _ex );         \
    SIDL_CHECK(*_ex);
  if ( instance == NULL) { return NULL; }
  self =
    (struct sidl_Loader__object*) malloc(
      sizeof(struct sidl_Loader__object));

  r_obj =
    (struct sidl_Loader__remote*) malloc(
      sizeof(struct sidl_Loader__remote));

  r_obj->d_refcount = 1;
  r_obj->d_ih = instance;
  s0 =                          self;
  s1 =                          &s0->d_sidl_baseclass;

  LOCK_STATIC_GLOBALS;
  if (!s_remote_initialized) {
    sidl_Loader__init_remote_epv();
  }
  UNLOCK_STATIC_GLOBALS;

  s1->d_sidl_baseinterface.d_epv    = &s_rem_epv__sidl_baseinterface;
  s1->d_sidl_baseinterface.d_object = (void*) self;

  s1->d_data = (void*) r_obj;
  s1->d_epv  = &s_rem_epv__sidl_baseclass;

  s0->d_data = (void*) r_obj;
  s0->d_epv  = &s_rem_epv__sidl_loader;

  self->d_data = (void*) r_obj;

  return self;
  EXIT:
  return NULL;
}
/* Create an instance that uses an already existing  */
/* InstanceHandle to connect to an existing remote object. */
static struct sidl_Loader__object*
sidl_Loader__IHConnect(sidl_rmi_InstanceHandle instance, sidl_BaseInterface   \
  *_ex)
{
  struct sidl_Loader__object* self;

  struct sidl_Loader__object* s0;
  struct sidl_BaseClass__object* s1;

  struct sidl_Loader__remote* r_obj;
  self =
    (struct sidl_Loader__object*) malloc(
      sizeof(struct sidl_Loader__object));

  r_obj =
    (struct sidl_Loader__remote*) malloc(
      sizeof(struct sidl_Loader__remote));

  r_obj->d_refcount = 1;
  r_obj->d_ih = instance;
  s0 =                          self;
  s1 =                          &s0->d_sidl_baseclass;

  LOCK_STATIC_GLOBALS;
  if (!s_remote_initialized) {
    sidl_Loader__init_remote_epv();
  }
  UNLOCK_STATIC_GLOBALS;

  s1->d_sidl_baseinterface.d_epv    = &s_rem_epv__sidl_baseinterface;
  s1->d_sidl_baseinterface.d_object = (void*) self;

  s1->d_data = (void*) r_obj;
  s1->d_epv  = &s_rem_epv__sidl_baseclass;

  s0->d_data = (void*) r_obj;
  s0->d_epv  = &s_rem_epv__sidl_loader;

  self->d_data = (void*) r_obj;

  sidl_rmi_InstanceHandle_addRef(instance,_ex);SIDL_CHECK(*_ex);
  return self;
  EXIT:
  return NULL;
}
/* REMOTE: generate remote instance given URL string. */
static struct sidl_Loader__object*
sidl_Loader__remoteCreate(const char *url, sidl_BaseInterface *_ex)
{
  sidl_BaseInterface _throwaway_exception = NULL;
  struct sidl_Loader__object* self;

  struct sidl_Loader__object* s0;
  struct sidl_BaseClass__object* s1;

  struct sidl_Loader__remote* r_obj;
  sidl_rmi_InstanceHandle instance = sidl_rmi_ProtocolFactory_createInstance( \
    url, "sidl.Loader", _ex ); SIDL_CHECK(*_ex);
  if ( instance == NULL) { return NULL; }
  self =
    (struct sidl_Loader__object*) malloc(
      sizeof(struct sidl_Loader__object));

  r_obj =
    (struct sidl_Loader__remote*) malloc(
      sizeof(struct sidl_Loader__remote));

  r_obj->d_refcount = 1;
  r_obj->d_ih = instance;
  s0 =                          self;
  s1 =                          &s0->d_sidl_baseclass;

  LOCK_STATIC_GLOBALS;
  if (!s_remote_initialized) {
    sidl_Loader__init_remote_epv();
  }
  UNLOCK_STATIC_GLOBALS;

  s1->d_sidl_baseinterface.d_epv    = &s_rem_epv__sidl_baseinterface;
  s1->d_sidl_baseinterface.d_object = (void*) self;

  s1->d_data = (void*) r_obj;
  s1->d_epv  = &s_rem_epv__sidl_baseclass;

  s0->d_data = (void*) r_obj;
  s0->d_epv  = &s_rem_epv__sidl_loader;

  self->d_data = (void*) r_obj;

  return self;
  EXIT:
  if(instance) { sidl_rmi_InstanceHandle_deleteRef(instance,                  \
    &_throwaway_exception); }
  return NULL;
}
/*
 * Cast method for interface and class type conversions.
 */

struct sidl_Loader__object*
sidl_Loader__rmicast(
  void* obj,
  sidl_BaseInterface* _ex)
{
  struct sidl_Loader__object* cast = NULL;

  *_ex = NULL;
  if(!connect_loaded) {
    sidl_rmi_ConnectRegistry_registerConnect("sidl.Loader", (                 \
      void*)sidl_Loader__IHConnect, _ex);
    connect_loaded = 1;
  }
  if (obj != NULL) {
    struct sidl_BaseInterface__object* base = (struct                         \
      sidl_BaseInterface__object*) obj;
    cast = (struct sidl_Loader__object*) (*base->d_epv->f__cast)(
      base->d_object,
      "sidl.Loader", _ex); SIDL_CHECK(*_ex);
  }

  return cast;
  EXIT:
  return NULL;
}

/*
 * RMI connector function for the class.
 */

struct sidl_Loader__object*
sidl_Loader__connectI(const char* url, sidl_bool ar, struct                   \
  sidl_BaseInterface__object **_ex)
{
  return sidl_Loader__remoteConnect(url, ar, _ex);
}

static PyObject *
pStub_Loader__connect(PyObject *_ignored, PyObject *_args, PyObject *_kwdict) \
  {
  PyObject *_return_value = NULL;
  struct sidl_Loader__object* self = NULL;
  char* url = NULL;
  struct sidl_BaseInterface__object *_exception = NULL;
  static char *_kwlist[] = {
    "url",
    NULL
  };
  int _okay;
  sidl_rmi_NetworkException__import();
  _okay = PyArg_ParseTupleAndKeywords(
    _args, _kwdict, 
    "z", _kwlist,
    &url);
  if (_okay) {
    self = sidl_Loader__remoteConnect(url,1,&_exception);
    if (_exception) {
      struct sidl_rmi_NetworkException__object *_ex0;
      if ((_ex0 = (struct sidl_rmi_NetworkException__object *)
      sidl_PyExceptionCast(_exception, "sidl.rmi.NetworkException"))) {
        struct sidl_BaseInterface__object *throwaway_exception;
        PyObject *_obj = sidl_rmi_NetworkException__wrap(_ex0);
        PyObject *_eargs = PyTuple_New(1);
        PyTuple_SetItem(_eargs, 0, _obj);
        _obj = PyObject_CallObject(sidl_rmi_NetworkException__type, _eargs);
        PyErr_SetObject(sidl_rmi_NetworkException__type, _obj);
        Py_XDECREF(_obj);
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
          &throwaway_exception);
        Py_XDECREF(_eargs);
      }
    }
    else {
      _return_value = Py_BuildValue(
        "O&",
        (void *)sidl_Loader__wrap, self);
    }
  }
  return _return_value;
}

staticforward PyTypeObject _sidl_LoaderType;

static struct sidl_Loader__sepv *_sepv = NULL;

static const struct sidl_Loader__external *_implEPV = NULL;

static PyObject *
pStub_Loader__exec(PyObject *_self, PyObject *_args, PyObject *_kwdict) {
  PyObject *_return_value = NULL;
  struct sidl_Loader__object *_self_ior =
    ((struct sidl_Loader__object *)
     sidl_Cast(_self, "sidl.Loader"));
  if (_self_ior) {
    char* methodName = NULL;
    struct sidl_rmi_Call__object* inArgs = NULL;
    struct sidl_rmi_Return__object* outArgs = NULL;
    struct sidl_BaseInterface__object *_exception = NULL;
    static char *_kwlist[] = {
      "methodName",
      "inArgs",
      "outArgs",
      NULL
    };
    int _okay;
    sidl_RuntimeException__import();
    sidl_rmi_Call__import();
    sidl_rmi_Return__import();
    _okay = PyArg_ParseTupleAndKeywords(
      _args, _kwdict, 
      "zO&O&", _kwlist,
      &methodName,
      (void *)sidl_rmi_Call__convert, &inArgs,
      (void *)sidl_rmi_Return__convert, &outArgs);
    if (_okay) {
      (*(_self_ior->d_epv->f__exec))(_self_ior, methodName, inArgs, outArgs,  \
        &_exception);
      if (_exception) {
        struct sidl_RuntimeException__object *_ex0;
        if ((_ex0 = (struct sidl_RuntimeException__object *)
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
          struct sidl_BaseInterface__object *throwaway_exception;
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
          PyObject *_eargs = PyTuple_New(1);
          PyTuple_SetItem(_eargs, 0, _obj);
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
          Py_XDECREF(_obj);
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
            &throwaway_exception);
          Py_XDECREF(_eargs);
        }
      }
      else {
        _return_value = Py_None;
        Py_INCREF(_return_value);
      }
      sidl_rmi_Call_deref(inArgs);
      sidl_rmi_Return_deref(outArgs);
    }
    {
      struct sidl_BaseInterface__object *throwaway_exception;
      (*(_self_ior->d_epv->f_deleteRef))(_self_ior, &throwaway_exception);
    }
  }
  else {
    PyErr_SetString(PyExc_TypeError, 
      "self pointer is not a sidl.Loader");
  }
  return _return_value;
}

static PyObject *
pStub_Loader__getURL(PyObject *_self, PyObject *_args, PyObject *_kwdict) {
  PyObject *_return_value = NULL;
  struct sidl_Loader__object *_self_ior =
    ((struct sidl_Loader__object *)
     sidl_Cast(_self, "sidl.Loader"));
  if (_self_ior) {
    struct sidl_BaseInterface__object *_exception = NULL;
    static char *_kwlist[] = {
      NULL
    };
    int _okay;
    sidl_RuntimeException__import();
    _okay = PyArg_ParseTupleAndKeywords(
      _args, _kwdict, 
      "", _kwlist);
    if (_okay) {
      char* _return = NULL;
      _return = (*(_self_ior->d_epv->f__getURL))(_self_ior, &_exception);
      if (_exception) {
        struct sidl_RuntimeException__object *_ex0;
        if ((_ex0 = (struct sidl_RuntimeException__object *)
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
          struct sidl_BaseInterface__object *throwaway_exception;
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
          PyObject *_eargs = PyTuple_New(1);
          PyTuple_SetItem(_eargs, 0, _obj);
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
          Py_XDECREF(_obj);
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
            &throwaway_exception);
          Py_XDECREF(_eargs);
        }
      }
      else {
        _return_value = Py_BuildValue(
          "z",
          _return);
        free((void *)_return);
      }
    }
    {
      struct sidl_BaseInterface__object *throwaway_exception;
      (*(_self_ior->d_epv->f_deleteRef))(_self_ior, &throwaway_exception);
    }
  }
  else {
    PyErr_SetString(PyExc_TypeError, 
      "self pointer is not a sidl.Loader");
  }
  return _return_value;
}

static PyObject *
pStub_Loader__isLocal(PyObject *_self, PyObject *_args, PyObject *_kwdict) {
  PyObject *_return_value = NULL;
  struct sidl_Loader__object *_self_ior =
    ((struct sidl_Loader__object *)
     sidl_Cast(_self, "sidl.Loader"));
  if (_self_ior) {
    struct sidl_BaseInterface__object *_exception = NULL;
    static char *_kwlist[] = {
      NULL
    };
    int _okay;
    sidl_RuntimeException__import();
    _okay = PyArg_ParseTupleAndKeywords(
      _args, _kwdict, 
      "", _kwlist);
    if (_okay) {
      sidl_bool _return = (sidl_bool) 0;
      int _proxy__return;
      _return = !(*(_self_ior->d_epv->f__isRemote))(_self_ior, &_exception);
      _proxy__return = _return;
      if (_exception) {
        struct sidl_RuntimeException__object *_ex0;
        if ((_ex0 = (struct sidl_RuntimeException__object *)
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
          struct sidl_BaseInterface__object *throwaway_exception;
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
          PyObject *_eargs = PyTuple_New(1);
          PyTuple_SetItem(_eargs, 0, _obj);
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
          Py_XDECREF(_obj);
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
            &throwaway_exception);
          Py_XDECREF(_eargs);
        }
      }
      else {
        _return_value = Py_BuildValue(
          "i",
          _proxy__return);
      }
    }
    {
      struct sidl_BaseInterface__object *throwaway_exception;
      (*(_self_ior->d_epv->f_deleteRef))(_self_ior, &throwaway_exception);
    }
  }
  else {
    PyErr_SetString(PyExc_TypeError, 
      "self pointer is not a sidl.Loader");
  }
  return _return_value;
}

static PyObject *
pStub_Loader__isRemote(PyObject *_self, PyObject *_args, PyObject *_kwdict) {
  PyObject *_return_value = NULL;
  struct sidl_Loader__object *_self_ior =
    ((struct sidl_Loader__object *)
     sidl_Cast(_self, "sidl.Loader"));
  if (_self_ior) {
    struct sidl_BaseInterface__object *_exception = NULL;
    static char *_kwlist[] = {
      NULL
    };
    int _okay;
    sidl_RuntimeException__import();
    _okay = PyArg_ParseTupleAndKeywords(
      _args, _kwdict, 
      "", _kwlist);
    if (_okay) {
      sidl_bool _return = (sidl_bool) 0;
      int _proxy__return;
      _return = (*(_self_ior->d_epv->f__isRemote))(_self_ior, &_exception);
      _proxy__return = _return;
      if (_exception) {
        struct sidl_RuntimeException__object *_ex0;
        if ((_ex0 = (struct sidl_RuntimeException__object *)
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
          struct sidl_BaseInterface__object *throwaway_exception;
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
          PyObject *_eargs = PyTuple_New(1);
          PyTuple_SetItem(_eargs, 0, _obj);
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
          Py_XDECREF(_obj);
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
            &throwaway_exception);
          Py_XDECREF(_eargs);
        }
      }
      else {
        _return_value = Py_BuildValue(
          "i",
          _proxy__return);
      }
    }
    {
      struct sidl_BaseInterface__object *throwaway_exception;
      (*(_self_ior->d_epv->f_deleteRef))(_self_ior, &throwaway_exception);
    }
  }
  else {
    PyErr_SetString(PyExc_TypeError, 
      "self pointer is not a sidl.Loader");
  }
  return _return_value;
}

static PyObject *
pStub_Loader__set_hooks(PyObject *_self, PyObject *_args, PyObject *_kwdict) {
  PyObject *_return_value = NULL;
  struct sidl_Loader__object *_self_ior =
    ((struct sidl_Loader__object *)
     sidl_Cast(_self, "sidl.Loader"));
  if (_self_ior) {
    sidl_bool on = (sidl_bool) 0;
    struct sidl_BaseInterface__object *_exception = NULL;
    int _proxy_on;
    static char *_kwlist[] = {
      "on",
      NULL
    };
    int _okay;
    sidl_RuntimeException__import();
    _okay = PyArg_ParseTupleAndKeywords(
      _args, _kwdict, 
      "i", _kwlist,
      &_proxy_on);
    if (_okay) {
      on = (_proxy_on ? (TRUE) : (FALSE));
      (*(_self_ior->d_epv->f__set_hooks))(_self_ior, on, &_exception);
      if (_exception) {
        struct sidl_RuntimeException__object *_ex0;
        if ((_ex0 = (struct sidl_RuntimeException__object *)
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
          struct sidl_BaseInterface__object *throwaway_exception;
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
          PyObject *_eargs = PyTuple_New(1);
          PyTuple_SetItem(_eargs, 0, _obj);
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
          Py_XDECREF(_obj);
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
            &throwaway_exception);
          Py_XDECREF(_eargs);
        }
      }
      else {
        _return_value = Py_None;
        Py_INCREF(_return_value);
      }
    }
    {
      struct sidl_BaseInterface__object *throwaway_exception;
      (*(_self_ior->d_epv->f_deleteRef))(_self_ior, &throwaway_exception);
    }
  }
  else {
    PyErr_SetString(PyExc_TypeError, 
      "self pointer is not a sidl.Loader");
  }
  return _return_value;
}

static PyObject *
pStub_Loader__set_hooks_static(PyObject *_ignored, PyObject *_args, PyObject  \
  *_kwdict) {
  PyObject *_return_value = NULL;
  sidl_bool on = (sidl_bool) 0;
  struct sidl_BaseInterface__object *_exception = NULL;
  int _proxy_on;
  static char *_kwlist[] = {
    "on",
    NULL
  };
  int _okay;
  sidl_RuntimeException__import();
  _okay = PyArg_ParseTupleAndKeywords(
    _args, _kwdict, 
    "i", _kwlist,
    &_proxy_on);
  if (_okay) {
    on = (_proxy_on ? (TRUE) : (FALSE));
    (*(_sepv->f__set_hooks_static))(on, &_exception);
    if (_exception) {
      struct sidl_RuntimeException__object *_ex0;
      if ((_ex0 = (struct sidl_RuntimeException__object *)
      sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
        struct sidl_BaseInterface__object *throwaway_exception;
        PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
        PyObject *_eargs = PyTuple_New(1);
        PyTuple_SetItem(_eargs, 0, _obj);
        _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
        PyErr_SetObject(sidl_RuntimeException__type, _obj);
        Py_XDECREF(_obj);
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
          &throwaway_exception);
        Py_XDECREF(_eargs);
      }
    }
    else {
      _return_value = Py_None;
      Py_INCREF(_return_value);
    }
  }
  if(_implEPV) {
    _sepv = (*_implEPV->getStaticEPV)();
  }
  return _return_value;
}

static PyObject *
pStub_Loader_addDLL(PyObject *_ignored, PyObject *_args, PyObject *_kwdict) {
  PyObject *_return_value = NULL;
  struct sidl_DLL__object* dll = NULL;
  struct sidl_BaseInterface__object *_exception = NULL;
  static char *_kwlist[] = {
    "dll",
    NULL
  };
  int _okay;
  sidl_DLL__import();
  sidl_RuntimeException__import();
  _okay = PyArg_ParseTupleAndKeywords(
    _args, _kwdict, 
    "O&", _kwlist,
    (void *)sidl_DLL__convert, &dll);
  if (_okay) {
    (*(_sepv->f_addDLL))(dll, &_exception);
    if (_exception) {
      struct sidl_RuntimeException__object *_ex0;
      if ((_ex0 = (struct sidl_RuntimeException__object *)
      sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
        struct sidl_BaseInterface__object *throwaway_exception;
        PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
        PyObject *_eargs = PyTuple_New(1);
        PyTuple_SetItem(_eargs, 0, _obj);
        _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
        PyErr_SetObject(sidl_RuntimeException__type, _obj);
        Py_XDECREF(_obj);
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
          &throwaway_exception);
        Py_XDECREF(_eargs);
      }
    }
    else {
      _return_value = Py_None;
      Py_INCREF(_return_value);
    }
    sidl_DLL_deref(dll);
  }
  return _return_value;
}

static PyObject *
pStub_Loader_addSearchPath(PyObject *_ignored, PyObject *_args, PyObject      \
  *_kwdict) {
  PyObject *_return_value = NULL;
  char* path_fragment = NULL;
  struct sidl_BaseInterface__object *_exception = NULL;
  static char *_kwlist[] = {
    "path_fragment",
    NULL
  };
  int _okay;
  sidl_RuntimeException__import();
  _okay = PyArg_ParseTupleAndKeywords(
    _args, _kwdict, 
    "z", _kwlist,
    &path_fragment);
  if (_okay) {
    (*(_sepv->f_addSearchPath))(path_fragment, &_exception);
    if (_exception) {
      struct sidl_RuntimeException__object *_ex0;
      if ((_ex0 = (struct sidl_RuntimeException__object *)
      sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
        struct sidl_BaseInterface__object *throwaway_exception;
        PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
        PyObject *_eargs = PyTuple_New(1);
        PyTuple_SetItem(_eargs, 0, _obj);
        _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
        PyErr_SetObject(sidl_RuntimeException__type, _obj);
        Py_XDECREF(_obj);
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
          &throwaway_exception);
        Py_XDECREF(_eargs);
      }
    }
    else {
      _return_value = Py_None;
      Py_INCREF(_return_value);
    }
  }
  return _return_value;
}

static PyObject *
pStub_Loader_findLibrary(PyObject *_ignored, PyObject *_args, PyObject        \
  *_kwdict) {
  PyObject *_return_value = NULL;
  char* sidl_name = NULL;
  char* target = NULL;
  enum sidl_Scope__enum lScope = (enum sidl_Scope__enum) 0;
  enum sidl_Resolve__enum lResolve = (enum sidl_Resolve__enum) 0;
  struct sidl_BaseInterface__object *_exception = NULL;
  long _proxy_lScope;
  long _proxy_lResolve;
  static char *_kwlist[] = {
    "sidl_name",
    "target",
    "lScope",
    "lResolve",
    NULL
  };
  int _okay;
  sidl_DLL__import();
  sidl_RuntimeException__import();
  _okay = PyArg_ParseTupleAndKeywords(
    _args, _kwdict, 
    "zzll", _kwlist,
    &sidl_name,
    &target,
    &_proxy_lScope,
    &_proxy_lResolve);
  if (_okay) {
    struct sidl_DLL__object* _return = NULL;
    lScope = _proxy_lScope;
    lResolve = _proxy_lResolve;
    _return = (*(_sepv->f_findLibrary))(sidl_name, target, lScope, lResolve,  \
      &_exception);
    if (_exception) {
      struct sidl_RuntimeException__object *_ex0;
      if ((_ex0 = (struct sidl_RuntimeException__object *)
      sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
        struct sidl_BaseInterface__object *throwaway_exception;
        PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
        PyObject *_eargs = PyTuple_New(1);
        PyTuple_SetItem(_eargs, 0, _obj);
        _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
        PyErr_SetObject(sidl_RuntimeException__type, _obj);
        Py_XDECREF(_obj);
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
          &throwaway_exception);
        Py_XDECREF(_eargs);
      }
    }
    else {
      _return_value = Py_BuildValue(
        "O&",
        (void *)sidl_DLL__wrap, _return);
    }
  }
  return _return_value;
}

static PyObject *
pStub_Loader_getFinder(PyObject *_ignored, PyObject *_args, PyObject          \
  *_kwdict) {
  PyObject *_return_value = NULL;
  struct sidl_BaseInterface__object *_exception = NULL;
  static char *_kwlist[] = {
    NULL
  };
  int _okay;
  sidl_Finder__import();
  sidl_RuntimeException__import();
  _okay = PyArg_ParseTupleAndKeywords(
    _args, _kwdict, 
    "", _kwlist);
  if (_okay) {
    struct sidl_Finder__object* _return = NULL;
    _return = (*(_sepv->f_getFinder))(&_exception);
    if (_exception) {
      struct sidl_RuntimeException__object *_ex0;
      if ((_ex0 = (struct sidl_RuntimeException__object *)
      sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
        struct sidl_BaseInterface__object *throwaway_exception;
        PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
        PyObject *_eargs = PyTuple_New(1);
        PyTuple_SetItem(_eargs, 0, _obj);
        _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
        PyErr_SetObject(sidl_RuntimeException__type, _obj);
        Py_XDECREF(_obj);
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
          &throwaway_exception);
        Py_XDECREF(_eargs);
      }
    }
    else {
      _return_value = Py_BuildValue(
        "O&",
        (void *)sidl_Finder__wrap, _return);
    }
  }
  return _return_value;
}

static PyObject *
pStub_Loader_getSearchPath(PyObject *_ignored, PyObject *_args, PyObject      \
  *_kwdict) {
  PyObject *_return_value = NULL;
  struct sidl_BaseInterface__object *_exception = NULL;
  static char *_kwlist[] = {
    NULL
  };
  int _okay;
  sidl_RuntimeException__import();
  _okay = PyArg_ParseTupleAndKeywords(
    _args, _kwdict, 
    "", _kwlist);
  if (_okay) {
    char* _return = NULL;
    _return = (*(_sepv->f_getSearchPath))(&_exception);
    if (_exception) {
      struct sidl_RuntimeException__object *_ex0;
      if ((_ex0 = (struct sidl_RuntimeException__object *)
      sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
        struct sidl_BaseInterface__object *throwaway_exception;
        PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
        PyObject *_eargs = PyTuple_New(1);
        PyTuple_SetItem(_eargs, 0, _obj);
        _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
        PyErr_SetObject(sidl_RuntimeException__type, _obj);
        Py_XDECREF(_obj);
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
          &throwaway_exception);
        Py_XDECREF(_eargs);
      }
    }
    else {
      _return_value = Py_BuildValue(
        "z",
        _return);
      free((void *)_return);
    }
  }
  return _return_value;
}

static PyObject *
pStub_Loader_loadLibrary(PyObject *_ignored, PyObject *_args, PyObject        \
  *_kwdict) {
  PyObject *_return_value = NULL;
  char* uri = NULL;
  sidl_bool loadGlobally = (sidl_bool) 0;
  sidl_bool loadLazy = (sidl_bool) 0;
  struct sidl_BaseInterface__object *_exception = NULL;
  int _proxy_loadGlobally;
  int _proxy_loadLazy;
  static char *_kwlist[] = {
    "uri",
    "loadGlobally",
    "loadLazy",
    NULL
  };
  int _okay;
  sidl_DLL__import();
  sidl_RuntimeException__import();
  _okay = PyArg_ParseTupleAndKeywords(
    _args, _kwdict, 
    "zii", _kwlist,
    &uri,
    &_proxy_loadGlobally,
    &_proxy_loadLazy);
  if (_okay) {
    struct sidl_DLL__object* _return = NULL;
    loadGlobally = (_proxy_loadGlobally ? (TRUE) : (FALSE));
    loadLazy = (_proxy_loadLazy ? (TRUE) : (FALSE));
    _return = (*(_sepv->f_loadLibrary))(uri, loadGlobally, loadLazy,          \
      &_exception);
    if (_exception) {
      struct sidl_RuntimeException__object *_ex0;
      if ((_ex0 = (struct sidl_RuntimeException__object *)
      sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
        struct sidl_BaseInterface__object *throwaway_exception;
        PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
        PyObject *_eargs = PyTuple_New(1);
        PyTuple_SetItem(_eargs, 0, _obj);
        _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
        PyErr_SetObject(sidl_RuntimeException__type, _obj);
        Py_XDECREF(_obj);
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
          &throwaway_exception);
        Py_XDECREF(_eargs);
      }
    }
    else {
      _return_value = Py_BuildValue(
        "O&",
        (void *)sidl_DLL__wrap, _return);
    }
  }
  return _return_value;
}

static PyObject *
pStub_Loader_setFinder(PyObject *_ignored, PyObject *_args, PyObject          \
  *_kwdict) {
  PyObject *_return_value = NULL;
  struct sidl_Finder__object* f = NULL;
  struct sidl_BaseInterface__object *_exception = NULL;
  static char *_kwlist[] = {
    "f",
    NULL
  };
  int _okay;
  sidl_Finder__import();
  sidl_RuntimeException__import();
  _okay = PyArg_ParseTupleAndKeywords(
    _args, _kwdict, 
    "O&", _kwlist,
    (void *)sidl_Finder__convert, &f);
  if (_okay) {
    (*(_sepv->f_setFinder))(f, &_exception);
    if (_exception) {
      struct sidl_RuntimeException__object *_ex0;
      if ((_ex0 = (struct sidl_RuntimeException__object *)
      sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
        struct sidl_BaseInterface__object *throwaway_exception;
        PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
        PyObject *_eargs = PyTuple_New(1);
        PyTuple_SetItem(_eargs, 0, _obj);
        _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
        PyErr_SetObject(sidl_RuntimeException__type, _obj);
        Py_XDECREF(_obj);
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
          &throwaway_exception);
        Py_XDECREF(_eargs);
      }
    }
    else {
      _return_value = Py_None;
      Py_INCREF(_return_value);
    }
    sidl_Finder_deref(f);
  }
  return _return_value;
}

static PyObject *
pStub_Loader_setSearchPath(PyObject *_ignored, PyObject *_args, PyObject      \
  *_kwdict) {
  PyObject *_return_value = NULL;
  char* path_name = NULL;
  struct sidl_BaseInterface__object *_exception = NULL;
  static char *_kwlist[] = {
    "path_name",
    NULL
  };
  int _okay;
  sidl_RuntimeException__import();
  _okay = PyArg_ParseTupleAndKeywords(
    _args, _kwdict, 
    "z", _kwlist,
    &path_name);
  if (_okay) {
    (*(_sepv->f_setSearchPath))(path_name, &_exception);
    if (_exception) {
      struct sidl_RuntimeException__object *_ex0;
      if ((_ex0 = (struct sidl_RuntimeException__object *)
      sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
        struct sidl_BaseInterface__object *throwaway_exception;
        PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
        PyObject *_eargs = PyTuple_New(1);
        PyTuple_SetItem(_eargs, 0, _obj);
        _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
        PyErr_SetObject(sidl_RuntimeException__type, _obj);
        Py_XDECREF(_obj);
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
          &throwaway_exception);
        Py_XDECREF(_eargs);
      }
    }
    else {
      _return_value = Py_None;
      Py_INCREF(_return_value);
    }
  }
  return _return_value;
}

static PyObject *
pStub_Loader_unloadLibraries(PyObject *_ignored, PyObject *_args, PyObject    \
  *_kwdict) {
  PyObject *_return_value = NULL;
  struct sidl_BaseInterface__object *_exception = NULL;
  static char *_kwlist[] = {
    NULL
  };
  int _okay;
  sidl_RuntimeException__import();
  _okay = PyArg_ParseTupleAndKeywords(
    _args, _kwdict, 
    "", _kwlist);
  if (_okay) {
    (*(_sepv->f_unloadLibraries))(&_exception);
    if (_exception) {
      struct sidl_RuntimeException__object *_ex0;
      if ((_ex0 = (struct sidl_RuntimeException__object *)
      sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
        struct sidl_BaseInterface__object *throwaway_exception;
        PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
        PyObject *_eargs = PyTuple_New(1);
        PyTuple_SetItem(_eargs, 0, _obj);
        _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
        PyErr_SetObject(sidl_RuntimeException__type, _obj);
        Py_XDECREF(_obj);
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
          &throwaway_exception);
        Py_XDECREF(_eargs);
      }
    }
    else {
      _return_value = Py_None;
      Py_INCREF(_return_value);
    }
  }
  return _return_value;
}

static int
sidl_Loader_createCast(PyObject *self, PyObject *args, PyObject *kwds) {
  struct sidl_Loader__object *optarg = NULL;
  char* url = NULL;
  PyObject * implObj = NULL;
  static char *_kwlist[] = {"sobj",  "url", "impl", NULL };
  int _okay = PyArg_ParseTupleAndKeywords(args, kwds, "|O&zO", _kwlist, (void \
    *)sidl_Loader__convert, &optarg, &url, &implObj);
  if (_okay) {
    if (!optarg && !url && !implObj) {
      struct sidl_BaseInterface__object *_exception;
      optarg = (*(_implEPV->createObject))(NULL,&_exception);
      if (_exception) {
        sidl_RuntimeException__import();
        {
          struct sidl_RuntimeException__object *_ex0;
          if ((_ex0 = (struct sidl_RuntimeException__object *)
          sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
            struct sidl_BaseInterface__object *throwaway_exception;
            PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
            PyObject *_eargs = PyTuple_New(1);
            PyTuple_SetItem(_eargs, 0, _obj);
            _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
            PyErr_SetObject(sidl_RuntimeException__type, _obj);
            Py_XDECREF(_obj);
            (*(_exception->d_epv->f_deleteRef))(_exception->d_object,         \
              &throwaway_exception);
            Py_XDECREF(_eargs);
          }
          return -1;
        }
      }
    }
    else if (!optarg && !url && implObj) {
      struct sidl_BaseInterface__object *_exception;
      Py_INCREF(implObj);
      optarg = (*(_implEPV->createObject))((void*)implObj,&_exception);
      if (_exception) {
        sidl_RuntimeException__import();
        {
          struct sidl_RuntimeException__object *_ex0;
          if ((_ex0 = (struct sidl_RuntimeException__object *)
          sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
            struct sidl_BaseInterface__object *throwaway_exception;
            PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
            PyObject *_eargs = PyTuple_New(1);
            PyTuple_SetItem(_eargs, 0, _obj);
            _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
            PyErr_SetObject(sidl_RuntimeException__type, _obj);
            Py_XDECREF(_obj);
            (*(_exception->d_epv->f_deleteRef))(_exception->d_object,         \
              &throwaway_exception);
            Py_XDECREF(_eargs);
          }
          return -1;
        }
      }
  }
  else if(url && !optarg && !implObj) {
    struct sidl_BaseInterface__object *_exception = NULL;
    optarg = sidl_Loader__remoteCreate(url,&_exception);
    if (_exception) {
      sidl_rmi_NetworkException__import();
      struct sidl_rmi_NetworkException__object *_ex0;
      if ((_ex0 = (struct sidl_rmi_NetworkException__object *)
      sidl_PyExceptionCast(_exception, "sidl.rmi.NetworkException"))) {
        struct sidl_BaseInterface__object *throwaway_exception;
        PyObject *_obj = sidl_rmi_NetworkException__wrap(_ex0);
        PyObject *_eargs = PyTuple_New(1);
        PyTuple_SetItem(_eargs, 0, _obj);
        _obj = PyObject_CallObject(sidl_rmi_NetworkException__type, _eargs);
        PyErr_SetObject(sidl_rmi_NetworkException__type, _obj);
        Py_XDECREF(_obj);
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
          &throwaway_exception);
        Py_XDECREF(_eargs);
      }
      return -1;
    }
  }
  /* OK, but fall though */
  else if(!url && optarg && !implObj) {}
  /* Error case. */
  else {
    return -1;
  }
  return sidl_Object_Init(
    (SPObject *)self,
    (struct sidl_BaseInterface__object *)optarg,
    sidl_PyStealRef);
}
return -1;
}

static PyMethodDef _LoaderModuleMethods[] = {
  { "addDLL", (PyCFunction)pStub_Loader_addDLL,
  (METH_VARARGS | METH_KEYWORDS),
"\
addDLL( in sidl.DLL dll)\n\
RETURNS\n\
    None\n\
RAISES\n\
    sidl.RuntimeException\n\
\n\
\
Append the specified DLL to the beginning of the list of already\n\
loaded DLLs."
   },
  { "addSearchPath", (PyCFunction)pStub_Loader_addSearchPath,
  (METH_VARARGS | METH_KEYWORDS),
"\
addSearchPath( in string path_fragment)\n\
RETURNS\n\
    None\n\
RAISES\n\
    sidl.RuntimeException\n\
\n\
\
Append the specified path fragment to the beginning of the\n\
current search path.  This method operates on the Loader's\n\
current <code>Finder</code>. This will add a path to the\n\
current search path. Normally, the search path is initialized\n\
from the SIDL_DLL_PATH environment variable."
   },
  { "findLibrary", (PyCFunction)pStub_Loader_findLibrary,
  (METH_VARARGS | METH_KEYWORDS),
"\
findLibrary( in string sidl_name,\n\
             in string target,\n\
             in sidl.Scope lScope,\n\
             in sidl.Resolve lResolve)\n\
RETURNS\n\
   (sidl.DLL _return)\n\
RAISES\n\
    sidl.RuntimeException\n\
\n\
\
Find a DLL containing the specified information for a sidl\n\
class. This method searches SCL files in the search path looking\n\
for a shared library that contains the client-side or IOR\n\
for a particular sidl class.\n\
\n\
This call is implemented by calling the current\n\
<code>Finder</code>. The default finder searches the local\n\
file system for <code>.scl</code> files to locate the\n\
target class/interface.\n\
\n\
@param sidl_name  the fully qualified (long) name of the\n\
class/interface to be found. Package names\n\
are separated by period characters from each\n\
other and the class/interface name.\n\
@param target     to find a client-side binding, this is\n\
normally the name of the language.\n\
To find the implementation of a class\n\
in order to make one, you should pass\n\
the string \"ior/impl\" here.\n\
@param lScope     this specifies whether the symbols should\n\
be loaded into the global scope, a local\n\
scope, or use the setting in the SCL file.\n\
@param lResolve   this specifies whether symbols should be\n\
resolved as needed (LAZY), completely\n\
resolved at load time (NOW), or use the\n\
setting from the SCL file.\n\
@return a non-NULL object means the search was successful.\n\
The DLL has already been added."
   },
  { "getFinder", (PyCFunction)pStub_Loader_getFinder,
  (METH_VARARGS | METH_KEYWORDS),
"\
getFinder()\n\
RETURNS\n\
   (sidl.Finder _return)\n\
RAISES\n\
    sidl.RuntimeException\n\
\n\
\
This method gets the <code>Finder</code> that <code>Loader</code>\n\
uses to find DLLs.  "
   },
  { "getSearchPath", (PyCFunction)pStub_Loader_getSearchPath,
  (METH_VARARGS | METH_KEYWORDS),
"\
getSearchPath()\n\
RETURNS\n\
   (string _return)\n\
RAISES\n\
    sidl.RuntimeException\n\
\n\
\
Return the current search path.  The default\n\
<code>Finder</code> initializes the search path\n\
from environment variable SIDL_DLL_PATH."
   },
  { "loadLibrary", (PyCFunction)pStub_Loader_loadLibrary,
  (METH_VARARGS | METH_KEYWORDS),
"\
loadLibrary( in string uri,\n\
             in bool loadGlobally,\n\
             in bool loadLazy)\n\
RETURNS\n\
   (sidl.DLL _return)\n\
RAISES\n\
    sidl.RuntimeException\n\
\n\
\
Load the specified library if it has not already been loaded.\n\
The URI format is defined in class <code>DLL</code>.  The search\n\
path is not searched to resolve the library name.\n\
\n\
@param uri          the URI to load. This can be a .la file\n\
(a metadata file produced by libtool) or\n\
a shared library binary (i.e., .so,\n\
.dll or whatever is appropriate for your\n\
OS)\n\
@param loadGlobally <code>true</code> means that the shared\n\
library symbols will be loaded into the\n\
global namespace; <code>false</code> \n\
means they will be loaded into a \n\
private namespace. Some operating systems\n\
may not be able to honor the value presented\n\
here.\n\
@param loadLazy     <code>true</code> instructs the loader to\n\
that symbols can be resolved as needed (lazy)\n\
instead of requiring everything to be resolved\n\
now.\n\
@return if the load was successful, a non-NULL DLL object is returned."
   },
  { "setFinder", (PyCFunction)pStub_Loader_setFinder,
  (METH_VARARGS | METH_KEYWORDS),
"\
setFinder( in sidl.Finder f)\n\
RETURNS\n\
    None\n\
RAISES\n\
    sidl.RuntimeException\n\
\n\
\
This method sets the <code>Finder</code> that\n\
<code>Loader</code> will use to find DLLs.  If no\n\
<code>Finder</code> is set or if NULL is passed in, the Default\n\
Finder <code>DFinder</code> will be used.\n\
\n\
Future calls to <code>findLibrary</code>,\n\
<code>addSearchPath</code>, <code>getSearchPath</code>, and\n\
<code>setSearchPath</code> are deligated to the\n\
<code>Finder</code> set here."
   },
  { "setSearchPath", (PyCFunction)pStub_Loader_setSearchPath,
  (METH_VARARGS | METH_KEYWORDS),
"\
setSearchPath( in string path_name)\n\
RETURNS\n\
    None\n\
RAISES\n\
    sidl.RuntimeException\n\
\n\
\
Set the search path, which is a semi-colon separated sequence of\n\
URIs as described in class <code>DLL</code>.  This method will\n\
invalidate any existing search path.\n\
\n\
This updates the search path in the current <code>Finder</code>."
   },
  { "unloadLibraries", (PyCFunction)pStub_Loader_unloadLibraries,
  (METH_VARARGS | METH_KEYWORDS),
"\
unloadLibraries()\n\
RETURNS\n\
    None\n\
RAISES\n\
    sidl.RuntimeException\n\
\n\
\
Unload all dynamic link libraries.  The library may no longer\n\
be used to access symbol names.  When the library is actually\n\
unloaded from the memory image depends on details of the operating\n\
system."
   },
  { "_connect", (PyCFunction)pStub_Loader__connect,
  (METH_VARARGS | METH_KEYWORDS),
"\
_connect( in string url)\n\
RETURNS\n\
   ( out sidl.Loader self)\n\
RAISES\n\
    sidl.rmi.NetworkException\n\
"
   },
  { "_set_hooks_static", (PyCFunction)pStub_Loader__set_hooks_static,
  (METH_VARARGS | METH_KEYWORDS),
"\
_set_hooks_static( in bool on)\n\
RETURNS\n\
    None\n\
RAISES\n\
    sidl.RuntimeException\n\
\n\
\
Static Method to set whether or not method hooks should be invoked."
   },
  { NULL, NULL }
};

static PyMethodDef _LoaderObjectMethods[] = {
  { "_exec", (PyCFunction)pStub_Loader__exec,
  (METH_VARARGS | METH_KEYWORDS),
"\
_exec( in string methodName,\n\
       in sidl.rmi.Call inArgs,\n\
       in sidl.rmi.Return outArgs)\n\
RETURNS\n\
    None\n\
RAISES\n\
    sidl.RuntimeException\n\
\n\
\
Select and execute a method by name"
   },
  { "_getURL", (PyCFunction)pStub_Loader__getURL,
  (METH_VARARGS | METH_KEYWORDS),
"\
_getURL()\n\
RETURNS\n\
   (string _return)\n\
RAISES\n\
    sidl.RuntimeException\n\
\n\
\
Get the URL of the Implementation of this object (for RMI)"
   },
  { "_isLocal", (PyCFunction)pStub_Loader__isLocal,
  (METH_VARARGS | METH_KEYWORDS),
"\
_isLocal()\n\
RETURNS\n\
   (bool _return)\n\
RAISES\n\
    sidl.RuntimeException\n\
\n\
\
TRUE if this object is local, false if remote"
   },
  { "_isRemote", (PyCFunction)pStub_Loader__isRemote,
  (METH_VARARGS | METH_KEYWORDS),
"\
_isRemote()\n\
RETURNS\n\
   (bool _return)\n\
RAISES\n\
    sidl.RuntimeException\n\
\n\
\
TRUE if this object is remote, false if local"
   },
  { "_set_hooks", (PyCFunction)pStub_Loader__set_hooks,
  (METH_VARARGS | METH_KEYWORDS),
"\
_set_hooks( in bool on)\n\
RETURNS\n\
    None\n\
RAISES\n\
    sidl.RuntimeException\n\
\n\
\
Method to set whether or not method hooks should be invoked."
   },
  { NULL, NULL }
};

static PyTypeObject _sidl_LoaderType = {
  PyObject_HEAD_INIT(NULL)
  0,      /* ob_size */
  "sidl.Loader.Loader", /* tp_name */
  0,      /* tp_basicsize */
  0,      /* tp_itemsize */
  0,      /* tp_dealloc */
  0,      /* tp_print */
  0,      /* tp_getattr */
  0,      /* tp_setattr */
  0,      /* tp_compare */
  0,      /* tp_repr */
  0,      /* tp_as_number */
  0,      /* tp_as_sequence */
  0,      /* tp_as_mapping */
  0,      /* tp_hash  */
  0,      /* tp_call */
  0,      /* tp_str */
  0,      /* tp_getattro */
  0,      /* tp_setattro */
  0,      /* tp_as_buffer */
  Py_TPFLAGS_DEFAULT, /* tp_flags */
  "\
\
Class <code>Loader</code> manages dyanamic loading and symbol name\n\
resolution for the sidl runtime system.  The <code>Loader</code> class\n\
manages a library search path and keeps a record of all libraries\n\
loaded through this interface, including the initial \"global\" symbols\n\
in the main program.\n\
\n\
Unless explicitly set, the <code>Loader</code> uses the default\n\
<code>sidl.Finder</code> implemented in <code>sidl.DFinder</code>.\n\
This class searches the filesystem for <code>.scl</code> files when\n\
trying to find a class. The initial path is taken from the\n\
environment variable SIDL_DLL_PATH, which is a semi-colon\n\
separated sequence of URIs as described in class <code>DLL</code>.", /* tp_doc */
  0,      /* tp_traverse */
  0,       /* tp_clear */
  0,       /* tp_richcompare */
  0,       /* tp_weaklistoffset */
  0,       /* tp_iter */
  0,       /* tp_iternext */
  _LoaderObjectMethods, /* tp_methods */
  0,       /* tp_members */
  0,       /* tp_getset */
  0,       /* tp_base */
  0,       /* tp_dict */
  0,       /* tp_descr_get */
  0,       /* tp_descr_set */
  0,       /* tp_dictoffset */
  sidl_Loader_createCast,   /* tp_init */
  0,       /* tp_alloc */
  0,       /* tp_new */
};

sidl_Loader__wrap_RETURN
sidl_Loader__wrap sidl_Loader__wrap_PROTO {
  PyObject *result;
  if (sidlobj) {
    result = _sidl_LoaderType.tp_new(&_sidl_LoaderType, NULL, NULL);
    if (result) {
      if (sidl_Object_Init(
        (SPObject *)result,
        (struct sidl_BaseInterface__object *)(sidlobj),
        sidl_PyStealRef))
      {
        Py_DECREF(result);
        result = NULL;
      }
    }
  }
  else {
    result = Py_None;
    Py_INCREF(result);
  }
  return result;
}

sidl_Loader__weakRef_RETURN
sidl_Loader__weakRef sidl_Loader__weakRef_PROTO {
  PyObject *result;
  if (sidlobj) {
    result = _sidl_LoaderType.tp_new(&_sidl_LoaderType, NULL, NULL);
    if (result) {
      if (sidl_Object_Init(
        (SPObject *)result,
        (struct sidl_BaseInterface__object *)(sidlobj),
        sidl_PyWeakRef))
      {
        Py_DECREF(result);
        result = NULL;
      }
    }
  }
  else {
    result = Py_None;
    Py_INCREF(result);
  }
  return result;
}

sidl_Loader_deref_RETURN
sidl_Loader_deref sidl_Loader_deref_PROTO {
  if (sidlobj) {
    struct sidl_BaseInterface__object *throwaway_exception;
    (*(sidlobj->d_epv->f_deleteRef))(sidlobj, &throwaway_exception);
  }
}

sidl_Loader__newRef_RETURN
sidl_Loader__newRef sidl_Loader__newRef_PROTO {
  PyObject *result;
  if (sidlobj) {
    result = _sidl_LoaderType.tp_new(&_sidl_LoaderType, NULL, NULL);
    if (result) {
      if (sidl_Object_Init(
        (SPObject *)result,
        (struct sidl_BaseInterface__object *)(sidlobj),
        sidl_PyNewRef))
      {
        Py_DECREF(result);
        result = NULL;
      }
    }
  }
  else {
    result = Py_None;
    Py_INCREF(result);
  }
  return result;
}

sidl_Loader__addRef_RETURN
sidl_Loader__addRef sidl_Loader__addRef_PROTO {
  if (sidlobj) {
    struct sidl_BaseInterface__object *throwaway_exception;
    (*(sidlobj->d_epv->f_addRef))(sidlobj, &throwaway_exception);
  }
}

sidl_Loader_PyType_RETURN
sidl_Loader_PyType sidl_Loader_PyType_PROTO {
  Py_INCREF(&_sidl_LoaderType);
  return &_sidl_LoaderType;
}

sidl_Loader__convert_RETURN
sidl_Loader__convert sidl_Loader__convert_PROTO {
  *sidlobj = sidl_Cast(obj, "sidl.Loader");
  if ((!(*sidlobj)) && (obj != Py_None)) {
    PyErr_SetString(PyExc_TypeError, 
      "argument is not a(n) sidl.Loader");
    return 0;
  }
  return 1;
}

static int
_convertPython(void *sidlarray, const int *ind, PyObject *pyobj)
{
  struct sidl_Loader__object *sidlobj;
  if (sidl_Loader__convert(pyobj, &sidlobj)) {
    sidl_interface__array_set((struct sidl_interface__array *)sidlarray,
    ind, (struct sidl_BaseInterface__object *)sidlobj);
    if (sidlobj) {
      struct sidl_BaseInterface__object *asInt = (struct                      \
        sidl_BaseInterface__object *)sidlobj;
      struct sidl_BaseInterface__object *throwaway_exception;
      (*asInt->d_epv->f_deleteRef)(asInt->d_object, &throwaway_exception);
    }
    return FALSE;
  }
  return TRUE;
}

sidl_Loader__convert_python_array_RETURN
sidl_Loader__convert_python_array sidl_Loader__convert_python_array_PROTO {
  int result = 0;
  *sidlarray = NULL;
  if (obj == Py_None) {
    result = TRUE;
  }
  else {
    PyObject *pya = PyArray_FromObject(obj, PyArray_OBJECT, 0, 0);
    if (pya) {
      if (PyArray_OBJECT == ((PyArrayObject *)pya)->descr->type_num) {
        int dimen, lower[SIDL_MAX_ARRAY_DIMENSION],
          upper[SIDL_MAX_ARRAY_DIMENSION],
          stride[SIDL_MAX_ARRAY_DIMENSION];
        if (sidl_array__extract_python_info
          (pya, &dimen, lower, upper, stride))
        {
            *sidlarray = (struct                                              \
              sidl_Loader__array*)sidl_interface__array_createRow
            (dimen, lower, upper);
          result = sidl_array__convert_python
            (pya, dimen, *sidlarray, _convertPython);
          if (*sidlarray && !result) {
            sidl_interface__array_deleteRef(
              (struct  sidl_interface__array *)*sidlarray);
            *sidlarray = NULL;
          }
        }
      }
      Py_DECREF(pya);
    }
  }
  return result;
}

static int
_convertSIDL(void *sidlarray, const int *ind, PyObject **dest)
{
  struct sidl_Loader__object *sidlobj = (struct sidl_Loader__object*)
  sidl_interface__array_get((struct sidl_interface__array *)
    sidlarray, ind);
  *dest = sidl_Loader__wrap(sidlobj);
  return (*dest == NULL);
}

sidl_Loader__convert_sidl_array_RETURN
sidl_Loader__convert_sidl_array sidl_Loader__convert_sidl_array_PROTO {
  PyObject *pya = NULL;
  if (sidlarray) {
    const int dimen = sidlArrayDim(sidlarray);
    int i;
    int *lower = (int *)malloc(sizeof(int) * dimen);
    int *upper = (int *)malloc(sizeof(int) * dimen);
    int *numelem = (int *)malloc(sizeof(int) * dimen);
    for(i = 0; i < dimen; ++i) {
      lower[i] = sidlLower(sidlarray, i);
      upper[i] = sidlUpper(sidlarray, i);
      numelem[i] = 1 + upper[i] - lower[i];
    }
    pya = PyArray_FromDims(dimen, numelem, PyArray_OBJECT);
    if (pya) {
      if (!sidl_array__convert_sidl(pya, dimen, lower, upper,
        numelem, sidlarray, _convertSIDL))
      {
        Py_DECREF(pya);
        pya = NULL;
      }
    }
    free(numelem);
    free(upper);
    free(lower);
  }
  else {
    Py_INCREF(Py_None);
    pya = Py_None;
  }
  return pya;
}

void
initLoader(void) {
  PyObject *module, *dict, *c_api;
  static void *ExternalAPI[sidl_Loader__API_NUM];
  struct sidl_BaseInterface__object *throwaway_exception;
  module = Py_InitModule3("Loader", _LoaderModuleMethods, "\
\
Class <code>Loader</code> manages dyanamic loading and symbol name\n\
resolution for the sidl runtime system.  The <code>Loader</code> class\n\
manages a library search path and keeps a record of all libraries\n\
loaded through this interface, including the initial \"global\" symbols\n\
in the main program.\n\
\n\
Unless explicitly set, the <code>Loader</code> uses the default\n\
<code>sidl.Finder</code> implemented in <code>sidl.DFinder</code>.\n\
This class searches the filesystem for <code>.scl</code> files when\n\
trying to find a class. The initial path is taken from the\n\
environment variable SIDL_DLL_PATH, which is a semi-colon\n\
separated sequence of URIs as described in class <code>DLL</code>."
  );
  dict = PyModule_GetDict(module);
  ExternalAPI[sidl_Loader__wrap_NUM] = (void*)sidl_Loader__wrap;
  ExternalAPI[sidl_Loader__convert_NUM] = (void*)sidl_Loader__convert;
  ExternalAPI[sidl_Loader__convert_python_array_NUM] = (                      \
    void*)sidl_Loader__convert_python_array;
  ExternalAPI[sidl_Loader__convert_sidl_array_NUM] = (                        \
    void*)sidl_Loader__convert_sidl_array;
  ExternalAPI[sidl_Loader__weakRef_NUM] = (void*)sidl_Loader__weakRef;
  ExternalAPI[sidl_Loader_deref_NUM] = (void*)sidl_Loader_deref;
  ExternalAPI[sidl_Loader__newRef_NUM] = (void*)sidl_Loader__newRef;
  ExternalAPI[sidl_Loader__addRef_NUM] = (void*)sidl_Loader__addRef;
  ExternalAPI[sidl_Loader_PyType_NUM] = (void*)sidl_Loader_PyType;
  ExternalAPI[sidl_Loader__connectI_NUM] = (void*)sidl_Loader__connectI;
  ExternalAPI[sidl_Loader__rmicast_NUM] = (void*)sidl_Loader__rmicast;
  import_SIDLObjA();
  if (PyErr_Occurred()) {
    Py_FatalError("Error importing sidlObjA module.");
  }
  c_api = PyCObject_FromVoidPtr((void *)ExternalAPI, NULL);
  PyDict_SetItemString(dict, "_C_API", c_api);
  Py_XDECREF(c_api);
  import_SIDLPyArrays();
  if (PyErr_Occurred()) {
    Py_FatalError("Error importing sidlPyArrays module.");
  }
  import_array();
  if (PyErr_Occurred()) {
    Py_FatalError("Error importing Numeric Python module.");
  }
  sidl_BaseClass__import();
  _sidl_LoaderType.tp_base = sidl_BaseClass_PyType();
  _sidl_LoaderType.tp_bases = PyTuple_New(1);
  PyTuple_SetItem(_sidl_LoaderType.tp_bases,0, (PyObject                      \
    *)sidl_BaseClass_PyType());
  if (PyType_Ready(&_sidl_LoaderType) < 0) {
    PyErr_Print();
    fprintf(stderr, "PyType_Ready on sidl.Loader failed.\n");
    return;
  }
  Py_INCREF(&_sidl_LoaderType);
  PyDict_SetItemString(dict, "Loader", (PyObject *)&_sidl_LoaderType);
  _implEPV = sidl_Loader__externals();
  if (_implEPV) {
    _sepv = (*_implEPV->getStaticEPV)();
    if (PyErr_Occurred()) {
      Py_FatalError("Cannot initialize Python module sidl.Loader.");
    }
  }
  else {
    Py_FatalError("Cannot load implementation for sidl class sidl.Loader");
  }

  sidl_rmi_ConnectRegistry_registerConnect("sidl.Loader", (                   \
    void*)sidl_Loader__IHConnect, &throwaway_exception);
}
